home *** CD-ROM | disk | FTP | other *** search
/ Aminet 48 / Aminet 48 (2002)(GTI - Schatztruhe)[!][Apr 2002].iso / Aminet / util / moni / Scout-src.lha / source / objects / scout_arexx.c < prev    next >
Encoding:
C/C++ Source or Header  |  2002-02-13  |  38.2 KB  |  1,431 lines
  1. /**
  2.  * Scout - The Amiga System Monitor
  3.  *
  4.  *------------------------------------------------------------------
  5.  *
  6.  * This program is free software; you can redistribute it and/or modify
  7.  * it under the terms of the GNU General Public License as published by
  8.  * the Free Software Foundation; either version 2 of the License, or
  9.  * any later version.
  10.  *
  11.  * This program is distributed in the hope that it will be useful,
  12.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.  * GNU General Public License for more details.
  15.  *
  16.  * You should have received a copy of the GNU General Public License
  17.  * along with this program; if not, write to the Free Software
  18.  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19.  *
  20.  * You must not use this source code to gain profit of any kind!
  21.  *
  22.  *------------------------------------------------------------------
  23.  *
  24.  * @author Andreas Gelhausen
  25.  * @author Richard Körber <rkoerber@gmx.de>
  26.  */
  27.  
  28.  
  29.  
  30. #include "system_headers.h"
  31.  
  32. /********************************************************************/
  33. /*            Hilfsroutinen für die ARexx-Funktionen                */
  34. /********************************************************************/
  35. BOOL IsReal (char *text) {
  36.    int   i = 0,punkte = 0;
  37.  
  38.    while (text[i]) {
  39.       if (text[i] == '.') {
  40.          if (punkte) {
  41.             return (FALSE);
  42.          }
  43.          punkte++;
  44.       } else if (! isdigit (text[i])) {
  45.          return (FALSE);
  46.       }
  47.       i++;
  48.    }
  49.    return (TRUE);
  50. }
  51.  
  52. BOOL IsHex (char *text, long *result) {
  53.    int i;
  54.  
  55.    if (text) {
  56.       if (text[0] == '$')
  57.          i = 1;
  58.       else if (! strnicmp ("0x", text, 2))
  59.          i = 2;
  60.       else 
  61.          return (FALSE);
  62.       
  63.       if (strlen (text + i) < 9) {
  64.          *result = strtol (text + i, NULL, 16);
  65.          return (TRUE);
  66.       }
  67.    }
  68.    return (FALSE);
  69. }
  70.  
  71. BOOL IsDec (char *text, long *result) {
  72.  
  73.    if ((text) && (strlen (text) < 9)) {
  74.       *result = atol (text);
  75.       return (TRUE);
  76.    }
  77.    return (FALSE);
  78. }
  79.  
  80. /*
  81. struct WinEntry *SearchWinEntry (UBYTE *title) {
  82.    struct   WinEntry *winentry;
  83.  
  84.    GetWindows (&winentry);
  85.    while (winentry) {
  86.       if ((winentry->wn_type == 'S') && (! strcmp (((struct Screen *) winentry->wn_adr)->Title, title)))
  87.          return (winentry);
  88.       if (! stricmp (((struct Window *) winentry->wn_adr)->Title, title))
  89.          return (winentry);
  90.       winentry = winentry->wn_next;
  91.    }
  92.    return (NULL);
  93. }
  94. */
  95.  
  96. /********************************************************************/
  97. /*                        ARexx-Funktionen                          */
  98. /********************************************************************/
  99. __asm __saveds long printlist_rxfunc (register __a1 ULONG *arg) {
  100.  
  101.    if (arg[2])
  102.       PrintHandleMode = MODE_OLDFILE;
  103.    else
  104.       PrintHandleMode = MODE_NEWFILE;
  105.  
  106.    if (stricmp ("L", (char *) arg[0]) == 0)
  107.       PrintLibraries ((char *) arg[1]);
  108.    else if (stricmp ("D", (char *) arg[0]) == 0)
  109.       PrintDevices ((char *) arg[1]);
  110.    else if (stricmp ("U", (char *) arg[0]) == 0)
  111.       PrintResources ((char *) arg[1]);
  112.    else if (stricmp ("T", (char *) arg[0]) == 0)
  113.       PrintTasks ((char *) arg[1]);
  114.    else if (stricmp ("P", (char *) arg[0]) == 0)
  115.       PrintPorts ((char *) arg[1]);
  116.    else if (stricmp ("C", (char *) arg[0]) == 0)
  117.       PrintCommands ((char *) arg[1]);
  118.    else if (stricmp ("X", (char *) arg[0]) == 0)
  119.       PrintExpansions ((char *) arg[1]);
  120.    else if (stricmp ("M", (char *) arg[0]) == 0)
  121.       PrintMemory ((char *) arg[1]);
  122.    else if (stricmp ("R", (char *) arg[0]) == 0)
  123.       PrintResidents ((char *) arg[1]);
  124.    else if (stricmp ("G", (char *) arg[0]) == 0)
  125.       PrintAssigns ((char *) arg[1]);
  126.    else if (stricmp ("O", (char *) arg[0]) == 0)
  127.       PrintLocks ((char *) arg[1]);
  128.    else if (stricmp ("N", (char *) arg[0]) == 0)
  129.       PrintMounts ((char *) arg[1]);
  130.    else if (stricmp ("H", (char *) arg[0]) == 0)
  131.       PrintInputHandlers ((char *) arg[1]);
  132.    else if (stricmp ("I", (char *) arg[0]) == 0)
  133.       PrintInterrupts ((char *) arg[1]);
  134.    else if (stricmp ("V", (char *) arg[0]) == 0)
  135.       PrintVectors ((char *) arg[1]);
  136.    else if (stricmp ("F", (char *) arg[0]) == 0)
  137.       PrintFonts ((char *) arg[1]);
  138.    else if (stricmp ("S", (char *) arg[0]) == 0)
  139.       PrintSemaphores ((char *) arg[1]);
  140.    else if (stricmp ("W", (char *) arg[0]) == 0)
  141.       PrintWindows ((char *) arg[1]);
  142.    else if (stricmp ("J", (char *) arg[0]) == 0)
  143.       PrintLowMemory ((char *) arg[1]);
  144.    else if (stricmp ("K", (char *) arg[0]) == 0)
  145.       PrintCx ((char *) arg[1]);
  146.    else if (stricmp ("Z", (char *) arg[0]) == 0)
  147.       PrintSMode ((char *) arg[1]);
  148.    else if (stricmp ("Y", (char *) arg[0]) == 0)
  149.       PrintSystem ((char *) arg[1]);
  150.    else if (stricmp ("A", (char *) arg[0]) == 0)
  151.       PrintAllocations ((char *) arg[1]);
  152.    else if (stricmp ("B", (char *) arg[0]) == 0)
  153.       PrintClass ((char *) arg[1]);
  154.    return (RETURN_OK);
  155. }
  156.  
  157. static const struct Hook printlist_rxhook = {
  158.    {NULL, NULL},
  159.    (void *)printlist_rxfunc,
  160.    NULL,NULL
  161. };
  162.  
  163. __asm __saveds long findtask_rxfunc (register __a1 ULONG *arg)
  164. {
  165.    struct   Task     *task;
  166.    long result = RETURN_ERROR;
  167.  
  168.    Forbid();
  169.    if (task = MyFindTask ((char *) arg[0])) {
  170.       if (SendResultString ("0x%08x", task)) result = RETURN_OK;
  171.    }
  172.    Permit();
  173.    return result;
  174. }
  175.  
  176. static const struct Hook findtask_rxhook = {
  177.    {NULL, NULL},
  178.    (void *)findtask_rxfunc,
  179.    NULL,NULL
  180. };
  181.  
  182. __asm __saveds long removetask_rxfunc (register __a1 ULONG *arg) {
  183.  
  184.    if (MyRemoveTask ((char *) arg[0], (BOOL) arg[1]))
  185.       return (RETURN_OK);
  186.    else
  187.       return (RETURN_ERROR);
  188. }
  189.  
  190. static const struct Hook removetask_rxhook = {
  191.    {NULL, NULL},
  192.    (void *)removetask_rxfunc,
  193.    NULL,NULL
  194. };
  195.  
  196. __asm __saveds long freezetask_rxfunc (register __a1 ULONG *arg) {
  197.  
  198.    if (MyFreezeTask ((char *) arg[0]))
  199.       return (RETURN_OK);
  200.    else
  201.       return (RETURN_ERROR);
  202. }
  203.  
  204. static const struct Hook freezetask_rxhook = {
  205.    {NULL, NULL},
  206.    (void *)freezetask_rxfunc,
  207.    NULL,NULL
  208. };
  209.  
  210.  
  211. __asm __saveds long activatetask_rxfunc (register __a1 ULONG *arg) {
  212.  
  213.    if (MyActivateTask ((char *) arg[0]))
  214.       return (RETURN_OK);
  215.    else
  216.       return (RETURN_ERROR);
  217. }
  218.  
  219. static const struct Hook activatetask_rxhook = {
  220.    {NULL, NULL},
  221.    (void *)activatetask_rxfunc,
  222.    NULL,NULL
  223. };
  224.  
  225. __asm __saveds long signaltask_rxfunc (register __a1 ULONG *arg) {
  226.  
  227.    if (MySignalTask ((char *) arg[0], (char *) arg[1]))
  228.       return (RETURN_OK);
  229.    else
  230.       return (RETURN_ERROR);
  231. }
  232.  
  233. static const struct Hook signaltask_rxhook = {
  234.    {NULL, NULL},
  235.    (void *)signaltask_rxfunc,
  236.    NULL,NULL
  237. };
  238.  
  239. __asm __saveds long breaktask_rxfunc (register __a1 ULONG *arg) {
  240.  
  241.    if (MySignalTask ((char *) arg[0], "0x1000"))
  242.       return (RETURN_OK);
  243.    else
  244.       return (RETURN_ERROR);
  245. }
  246.  
  247. static const struct Hook breaktask_rxhook = {
  248.    {NULL, NULL},
  249.    (void *)breaktask_rxfunc,
  250.    NULL,NULL
  251. };
  252.  
  253. __asm __saveds long settaskpri_rxfunc (register __a1 ULONG *arg)
  254. {
  255.    struct   Task     *task;
  256.    long     pri, result = RETURN_ERROR;
  257.  
  258.    Forbid();
  259.    if ((task = MyFindTask ((char *) arg[0])) && (IsDec ((char *) arg[1], &pri))) {
  260.       SetTaskPri (task, (int) pri);
  261.       result = RETURN_OK;
  262.    }
  263.    Permit();
  264.  
  265.    return result;
  266. }
  267.  
  268. static const struct Hook settaskpri_rxhook = {
  269.    {NULL, NULL},
  270.    (void *)settaskpri_rxfunc,
  271.    NULL,NULL
  272. };
  273.  
  274. __asm __saveds long removeport_rxfunc (register __a1 ULONG *arg) {
  275.    struct   MsgPort  *port;
  276.  
  277.    if (port = (struct MsgPort *) MyFindName ("PORT", (char *) arg[0])) {
  278.       RemPort (port);
  279.       return (RETURN_OK);
  280.    }
  281.    return (RETURN_ERROR);
  282. }
  283.  
  284. static const struct Hook removeport_rxhook = {
  285.    {NULL, NULL},
  286.    (void *)removeport_rxfunc,
  287.    NULL,NULL
  288. };
  289.  
  290. __asm __saveds long getlocknumber_rxfunc (register __a1 ULONG *arg) {
  291.  
  292.    GetLocks (SL_COUNT, (char *) arg[0], NULL);
  293.  
  294.    if (SendResultString ("%d", lockanzahl))
  295.       return (RETURN_OK);
  296.    return (RETURN_ERROR);
  297. }
  298.  
  299. static const struct Hook getlocknumber_rxhook = {
  300.    {NULL, NULL},
  301.    (void *)getlocknumber_rxfunc,
  302.    NULL,NULL
  303. };
  304.  
  305. __asm __saveds long removelocks_rxfunc (register __a1 ULONG *arg) {
  306.  
  307.    GetLocks (SL_REMOVE, (char *) *arg, NULL);
  308.    return (RETURN_OK);
  309. }
  310.  
  311. static const struct Hook removelocks_rxhook = {
  312.    {NULL, NULL},
  313.    (void *)removelocks_rxfunc,
  314.    NULL,NULL
  315. };
  316.  
  317. __asm __saveds long removelock_rxfunc (register __a1 ULONG *arg) {
  318.    long  nobptr;
  319.  
  320.    if (IsHex ((char *) arg[0], &nobptr)) {
  321.       UnLock ((BPTR) nobptr>>2);
  322.       return (RETURN_OK);
  323.    }
  324.    return (RETURN_ERROR);
  325. }
  326.  
  327. static const struct Hook removelock_rxhook = {
  328.    {NULL, NULL},
  329.    (void *)removelock_rxfunc,
  330.    NULL,NULL
  331. };
  332.  
  333. __asm __saveds long getpriority_rxfunc (register __a1 ULONG *arg) {
  334.    long  address;
  335.  
  336.    if (IsHex ((char *) arg[0], &address)) {
  337.       if (SendResultString ("%d", ((struct Node *) address)->ln_Pri))
  338.          return (RETURN_OK);
  339.    }
  340.    return (RETURN_ERROR);
  341. }
  342.  
  343. static const struct Hook getpriority_rxhook = {
  344.    {NULL, NULL},
  345.    (void *)getpriority_rxfunc,
  346.    NULL,NULL
  347. };
  348.  
  349. __asm __saveds long setpriority_rxfunc (register __a1 ULONG *arg) {
  350.    struct   Node  *node;
  351.    struct   List  *list;
  352.    int      value;
  353.  
  354.    if ((list = MyGetList ((char *) arg[0])) \
  355.      && (node = MyFindName ((char *) arg[0], (char *) arg[1]))) {
  356.  
  357.       value = (int) *(ULONG *) arg[2];
  358.       if ((value < 128) && (value > -129)) {
  359.  
  360.          Remove (node);
  361.          node->ln_Pri = value;
  362.          Enqueue (list, node);
  363.  
  364.          return (RETURN_OK);
  365.       }
  366.    }
  367.    return (RETURN_ERROR);
  368. }
  369.  
  370. static const struct Hook setpriority_rxhook = {
  371.    {NULL, NULL},
  372.    (void *)setpriority_rxfunc,
  373.    NULL,NULL
  374. };
  375.  
  376. __asm __saveds long findnode_rxfunc (register __a1 ULONG *arg) {
  377.    struct   Node  *node;
  378.  
  379.    if (node = MyFindName ((char *) arg[0], (char *) arg[1])) {
  380.       if (SendResultString ("0x%08x", node))
  381.          return (RETURN_OK);
  382.    }
  383.    return (RETURN_ERROR);
  384. }
  385.  
  386. static const struct Hook findnode_rxhook = {
  387.    {NULL, NULL},
  388.    (void *)findnode_rxfunc,
  389.    NULL,NULL
  390. };
  391.  
  392. __asm __saveds long closelib_rxfunc (register __a1 ULONG *arg) {
  393.    struct   Node  *node;
  394.  
  395.    if (node = MyFindName ("LIBRARY", (char *) arg[0])) {
  396.       CloseLibrary ((struct Library *) node);
  397.       return (RETURN_OK);
  398.    }
  399.    return (RETURN_ERROR);
  400. }
  401.  
  402. static const struct Hook closelib_rxhook = {
  403.    {NULL, NULL},
  404.    (void *)closelib_rxfunc,
  405.    NULL,NULL
  406. };
  407.  
  408. __asm __saveds long removelib_rxfunc (register __a1 ULONG *arg) {
  409.    struct   Node  *node;
  410.  
  411.    if (node = MyFindName ("LIBRARY", (char *) arg[0])) {
  412.       RemLibrary ((struct Library *) node);
  413.       return (RETURN_OK);
  414.    }
  415.    return (RETURN_ERROR);
  416. }
  417.  
  418. static const struct Hook removelib_rxhook = {
  419.    {NULL, NULL},
  420.    (void *)removelib_rxfunc,
  421.    NULL,NULL
  422. };
  423.  
  424. __asm __saveds long removedev_rxfunc (register __a1 ULONG *arg) {
  425.    struct   Node  *node;
  426.  
  427.    if (node = MyFindName ("DEVICE", (char *) arg[0])) {
  428.       RemDevice ((struct Device *) node);
  429.       return (RETURN_OK);
  430.    }
  431.    return (RETURN_ERROR);
  432. }
  433.  
  434. static const struct Hook removedev_rxhook = {
  435.    {NULL, NULL},
  436.    (void *)removedev_rxfunc,
  437.    NULL,NULL
  438. };
  439.  
  440. __asm __saveds long removeres_rxfunc (register __a1 ULONG *arg) {
  441.    struct   Node  *node;
  442.  
  443.    if (node = MyFindName ("RESOURCE", (char *) arg[0])) {
  444.       RemResource ((struct Library *) node);
  445.       return (RETURN_OK);
  446.    }
  447.    return (RETURN_ERROR);
  448. }
  449.  
  450. static const struct Hook removeres_rxhook = {
  451.    {NULL, NULL},
  452.    (void *)removeres_rxfunc,
  453.    NULL,NULL
  454. };
  455.  
  456. __asm __saveds long obtainsem_rxfunc (register __a1 ULONG *arg) {
  457.    struct   Node  *node;
  458.  
  459.    if (node = MyFindName ("SEMAPHORE", (char *) arg[0])) {
  460.       ObtainSemaphore ((struct SignalSemaphore *) node);
  461.       return (RETURN_OK);
  462.    }
  463.    return (RETURN_ERROR);
  464. }
  465.  
  466. static const struct Hook obtainsem_rxhook = {
  467.    {NULL, NULL},
  468.    (void *)obtainsem_rxfunc,
  469.    NULL,NULL
  470. };
  471.  
  472. __asm __saveds long releasesem_rxfunc (register __a1 ULONG *arg) {
  473.    struct   Node  *node;
  474.  
  475.    if ((node = MyFindName ("SEMAPHORE", (char *) arg[0])) \
  476.       && (((struct SignalSemaphore *) node)->ss_NestCount)) {
  477.       ReleaseSemaphore ((struct SignalSemaphore *) node);
  478.       return (RETURN_OK);
  479.    }
  480.    return (RETURN_ERROR);
  481. }
  482.  
  483. static const struct Hook releasesem_rxhook = {
  484.    {NULL, NULL},
  485.    (void *)releasesem_rxfunc,
  486.    NULL,NULL
  487. };
  488.  
  489. __asm __saveds long removesem_rxfunc (register __a1 ULONG *arg) {
  490.    struct   Node  *node;
  491.  
  492.    if (node = MyFindName ("SEMAPHORE", (char *) arg[0])) {
  493.       RemSemaphore ((struct SignalSemaphore *) node);
  494.       return (RETURN_OK);
  495.    }
  496.    return (RETURN_ERROR);
  497. }
  498.  
  499. static const struct Hook removesem_rxhook = {
  500.    {NULL, NULL},
  501.    (void *)removesem_rxfunc,
  502.    NULL,NULL
  503. };
  504.  
  505. __asm __saveds long removeinput_rxfunc (register __a1 ULONG *arg) {
  506.    struct   Node  *node;
  507.  
  508.    if (node = MyFindName ("INPUTHANDLER", (char *) arg[0])) {
  509.       InputIORequest->io_Command = IND_REMHANDLER;
  510.       InputIORequest->io_Data = (void *) node;
  511.       SendIO ((struct IORequest *) InputIORequest);
  512.       return (RETURN_OK);
  513.    }
  514.    return (RETURN_ERROR);
  515. }
  516.  
  517. static const struct Hook removeinput_rxhook = {
  518.    {NULL, NULL},
  519.    (void *)removeinput_rxfunc,
  520.    NULL,NULL
  521. };
  522.  
  523. __asm __saveds long removelowmemory_rxfunc (register __a1 ULONG *arg) {
  524.    struct Interrupt *intr;
  525.  
  526.    if (intr = (struct Interrupt *)MyFindName ("LOWMEMORY", (char *) arg[0])) {
  527.       if (SysBase->LibNode.lib_Version >= 39)
  528.          RemMemHandler(intr);
  529.       return (RETURN_OK);
  530.    }
  531.    return (RETURN_ERROR);
  532. }
  533.  
  534. static const struct Hook removelowmemory_rxhook = {
  535.    {NULL, NULL},
  536.    (void *)removelowmemory_rxfunc,
  537.    NULL,NULL
  538. };
  539.  
  540. /*
  541. __asm __saveds long causelowmem_rxfunc (register __a1 ULONG *arg) {
  542.    struct Interrupt *intr;
  543.    struct MemHandlerData mhd = {1000,MEMF_ANY,0};
  544.  
  545.    if (intr = (struct Interrupt *)MyFindName ("LOWMEMORY", (char *) arg[0])) {
  546.       MyCause(intr,&mhd);
  547.       return (RETURN_OK);
  548.    }
  549.    return (RETURN_ERROR);
  550. }
  551.  
  552. static const struct Hook causelowmem_rxhook = {
  553.    {NULL, NULL},
  554.    (void *)causelowmem_rxfunc,
  555.    NULL,NULL
  556. };
  557. */
  558.  
  559. __asm __saveds long findresident_rxfunc (register __a1 ULONG *arg) {
  560.    struct   Resident *resi;
  561.  
  562.    if (resi = FindResident ((char *) arg[0])) {
  563.       if (SendResultString ("0x%08x", resi))
  564.          return (RETURN_OK);
  565.    }
  566.    return (RETURN_ERROR);
  567. }
  568.  
  569. static const struct Hook findresident_rxhook = {
  570.    {NULL, NULL},
  571.    (void *)findresident_rxfunc,
  572.    NULL,NULL
  573. };
  574.  
  575. __asm __saveds long findinterrupt_rxfunc (register __a1 ULONG *arg) {
  576.    struct   Interrupt   *intr;
  577.  
  578.    if (intr = GetInterrupts (SI_FIND, (char *) arg[0], NULL)) {
  579.       if (SendResultString ("0x%08x", intr))
  580.          return (RETURN_OK);
  581.    }
  582.    return (RETURN_ERROR);
  583. }
  584.  
  585. static const struct Hook findinterrupt_rxhook = {
  586.    {NULL, NULL},
  587.    (void *)findinterrupt_rxfunc,
  588.    NULL,NULL
  589. };
  590.  
  591. __asm __saveds long removeinterrupt_rxfunc (register __a1 ULONG *arg) {
  592.    struct Interrupt *intr;
  593.    
  594.    if (intr = GetInterrupts (SI_REMOVE, (char *) arg[0], NULL)) {
  595.       return (RETURN_OK);
  596.    }
  597.    return (RETURN_ERROR);
  598. }
  599.  
  600. static const struct Hook removeinterrupt_rxhook = {
  601.    {NULL, NULL},
  602.    (void *)removeinterrupt_rxfunc,
  603.    NULL,NULL
  604. };
  605.  
  606. __asm __saveds long removeclass_rxfunc (register __a1 ULONG *arg) {
  607.    struct IClass *node;
  608.    BOOL ret;
  609.  
  610.    if (node = (struct IClass *)MyFindName ("CLASSES", (char *) arg[0])) {
  611.       if((!node->cl_ObjectCount) && (!node->cl_SubclassCount))
  612.       {
  613.         ret = FreeClass((struct IClass *)node);
  614.         return (ret ? RETURN_OK : RETURN_ERROR);
  615.       }
  616.    }
  617.    return (RETURN_ERROR);
  618. }
  619.  
  620. static const struct Hook removeclass_rxhook = {
  621.    {NULL, NULL},
  622.    (void *)removeclass_rxfunc,
  623.    NULL,NULL
  624. };
  625.  
  626.  
  627. __asm __saveds long flushdevs_rxfunc (register __a1 ULONG *arg) {
  628.    FlushDevices();
  629.    return (RETURN_OK);
  630. }
  631.  
  632. static const struct Hook flushdevs_rxhook = {
  633.    {NULL, NULL},
  634.    (void *)flushdevs_rxfunc,
  635.    NULL,NULL
  636. };
  637.  
  638. __asm __saveds long flushfonts_rxfunc (register __a1 ULONG *arg) {
  639.    FlushFonts();
  640.    return (RETURN_OK);
  641. }
  642.  
  643. static const struct Hook flushfonts_rxhook = {
  644.    {NULL, NULL},
  645.    (void *)flushfonts_rxfunc,
  646.    NULL,NULL
  647. };
  648.  
  649. __asm __saveds long flushlibs_rxfunc (register __a1 ULONG *arg) {
  650.    FlushLibraries();
  651.    return (RETURN_OK);
  652. }
  653.  
  654. static const struct Hook flushlibs_rxhook = {
  655.    {NULL, NULL},
  656.    (void *)flushlibs_rxfunc,
  657.    NULL,NULL
  658. };
  659.  
  660. __asm __saveds long flushall_rxfunc (register __a1 ULONG *arg) {
  661.    FlushDevices();
  662.    FlushFonts();
  663.    FlushLibraries();
  664.    return (RETURN_OK);
  665. }
  666.  
  667. static const struct Hook flushall_rxhook = {
  668.    {NULL, NULL},
  669.    (void *)flushall_rxfunc,
  670.    NULL,NULL
  671. };
  672.  
  673. __asm __saveds long clearreset_rxfunc (register __a1 ULONG *arg) {
  674.    ClearResetVectors();
  675.    return (RETURN_OK);
  676. }
  677.  
  678. static const struct Hook clearreset_rxhook = {
  679.    {NULL, NULL},
  680.    (void *)clearreset_rxfunc,
  681.    NULL,NULL
  682. };
  683.  
  684. __asm __saveds long poptofront_rxfunc (register __a1 ULONG *arg) {
  685.    struct   Window   *window;
  686.    struct   Screen   *screen;
  687.    
  688.    if (screen = MyFindScreen ((char *) arg[0])) {
  689.       ScreenToFront (screen);
  690.       return (RETURN_OK);
  691.    } else if (window = MyFindWindow ((char *) arg[0])) {
  692.       WindowToFront (window);
  693.       return (RETURN_OK);
  694.    }
  695.    return (RETURN_ERROR);
  696. }
  697.  
  698. static const struct Hook poptofront_rxhook = {
  699.    {NULL, NULL},
  700.    (void *)poptofront_rxfunc,
  701.    NULL,NULL
  702. };
  703.  
  704. __asm __saveds long closewindow_rxfunc (register __a1 ULONG *arg) {
  705.    struct   Window   *window;
  706.  
  707.    if (window = MyFindWindow ((char *) arg[0])) {
  708.       CloseWindow (window);
  709.       return (RETURN_OK);
  710.    }
  711.    return (RETURN_ERROR);
  712. }
  713.  
  714. static const struct Hook closewindow_rxhook = {
  715.    {NULL, NULL},
  716.    (void *)closewindow_rxfunc,
  717.    NULL,NULL
  718. };
  719.  
  720. __asm __saveds long closescreen_rxfunc (register __a1 ULONG *arg) {
  721.    struct   Screen   *screen;
  722.  
  723.    if (screen = MyFindScreen ((char *) arg[0])) {
  724.       CloseScreenAll (screen);
  725.       return (RETURN_OK);
  726.    }
  727.    return (RETURN_ERROR);
  728. }
  729.  
  730. static const struct Hook closescreen_rxhook = {
  731.    {NULL, NULL},
  732.    (void *)closescreen_rxfunc,
  733.    NULL,NULL
  734. };
  735.  
  736. __asm __saveds long closefont_rxfunc (register __a1 ULONG *arg) {
  737.    struct TextFont *font;
  738.  
  739.    if (IsHex ((char *) arg[0], (long *) &font)) {
  740.       CloseFont (font);
  741.       return (RETURN_OK);
  742.    }
  743.    return (RETURN_ERROR);
  744. }
  745.  
  746. static const struct Hook closefont_rxhook = {
  747.    {NULL, NULL},
  748.    (void *)closefont_rxfunc,
  749.    NULL,NULL
  750. };
  751.  
  752. __asm __saveds long removefont_rxfunc (register __a1 ULONG *arg) {
  753.    struct TextFont *font;
  754.  
  755.    if (IsHex ((char *) arg[0], (long *) &font)) {
  756.       RemFont (font);
  757.       Remove ((struct Node *) font);
  758.       return (RETURN_OK);
  759.    }
  760.    return (RETURN_ERROR);
  761. }
  762.  
  763. static const struct Hook removefont_rxhook = {
  764.    {NULL, NULL},
  765.    (void *)removefont_rxfunc,
  766.    NULL,NULL
  767. };
  768.  
  769. __asm __saveds long removecommand_rxfunc (register __a1 ULONG *arg) {
  770.    struct   Segment *seg;
  771.  
  772.    if ((IsHex ((char *) arg[0], (long *) &seg)) && (RemSegment (seg))) {
  773.       return (RETURN_OK);
  774.    }
  775.    return (RETURN_ERROR);
  776. }
  777.  
  778. static const struct Hook removecommand_rxhook = {
  779.    {NULL, NULL},
  780.    (void *)removecommand_rxfunc,
  781.    NULL,NULL
  782. };
  783.  
  784. __asm __saveds long removeassign_rxfunc (register __a1 ULONG *arg) {
  785.  
  786.    if (AssignLock((char *) arg[0], (BPTR)NULL)) {
  787.       return (RETURN_OK);
  788.    }
  789.    return (RETURN_ERROR);
  790. }
  791.  
  792. static const struct Hook removeassign_rxhook = {
  793.    {NULL, NULL},
  794.    (void *)removeassign_rxfunc,
  795.    NULL,NULL
  796. };
  797.  
  798. __asm __saveds long removeassignlist_rxfunc (register __a1 ULONG *arg) {
  799.    BPTR  address;
  800.  
  801.    if (IsHex ((char *) arg[1], (long *) &address)) {
  802.       if (RemAssignList ((char *) arg[0], address)) {
  803.          return (RETURN_OK);
  804.       }
  805.    }
  806.    return (RETURN_ERROR);
  807. }
  808.  
  809. static const struct Hook removeassignlist_rxhook = {
  810.    {NULL, NULL},
  811.    (void *)removeassignlist_rxfunc,
  812.    NULL,NULL
  813. };
  814.  
  815. char  *WindowTexte[] = { AssignsText,DevicesText,CommandsText,
  816.                          ExpansionsText,FontsText,InputHandlersText,
  817.                          InterruptsText,LibrariesText,LocksText,
  818.                          MemoryText,MountText,PortsText,
  819.                          ResidentsText,ResourcesText,SemaphoresText,
  820.                          TasksText,VectorsText,WindowsText,
  821.                          CommoditiesText,LowMemoryText,SystemText,ScreenModeText,ClassesText,
  822.                          AllocationsText,TimerText,NULL
  823.                        };
  824.  
  825. BYTE  WindowIDs[] = { ID_ASSIGNS,ID_DEVICES,ID_COMMANDS,
  826.                       ID_EXPANSIONS,ID_FONTS,ID_INPUTHANDLER,
  827.                       ID_INTERRUPTS,ID_LIBRARIES,ID_LOCKS,
  828.                       ID_MEMORY,ID_MOUNT,ID_PORTS,
  829.                       ID_RESIDENTS,ID_RESOURCES,ID_SEMAPHORES,
  830.                       ID_TASKS,ID_VECTORS,ID_WINDOWS,
  831.                       ID_COMMODITIES,ID_LOWMEMORY,ID_SYSTEM,
  832.                       ID_SCREENMODE, ID_CLASSES, ID_ALLOCATIONS, ID_TIMER
  833.                     };
  834.  
  835. __asm __saveds long openwindow_rxfunc (register __a1 ULONG *arg) {
  836.    int i = 0;
  837.  
  838.    if (AP_Scout) {
  839.       while (WindowTexte[i]) {
  840.          if (! stricmp ((char *) *arg, WindowTexte[i])) {
  841.  
  842.             DoMethod (AP_Scout,MUIM_Application_ReturnID,WindowIDs[i]);
  843.             return (RETURN_OK);
  844.          }
  845.          i++;
  846.       }
  847.    }
  848.    return (RETURN_ERROR);
  849. }
  850.  
  851. static const struct Hook openwindow_rxhook = {
  852.    {NULL, NULL},
  853.    (void *)openwindow_rxfunc,
  854.    NULL,NULL
  855. };
  856.  
  857.  
  858.  
  859. __asm __saveds long cxappear_rxfunc (register __a1 ULONG *arg) {
  860.    return(BrokerCommand((char *) arg[0], CXCMD_APPEAR ) ? RETURN_ERROR : RETURN_OK);
  861. }
  862. static const struct Hook cxappear_rxhook = {
  863.    {NULL, NULL},
  864.    (void *)cxappear_rxfunc,
  865.    NULL,NULL
  866. };
  867.  
  868. __asm __saveds long cxdisappear_rxfunc (register __a1 ULONG *arg) {
  869.    return(BrokerCommand((char *) arg[0], CXCMD_DISAPPEAR ) ? RETURN_ERROR : RETURN_OK);
  870. }
  871. static const struct Hook cxdisappear_rxhook = {
  872.    {NULL, NULL},
  873.    (void *)cxdisappear_rxfunc,
  874.    NULL,NULL
  875. };
  876.  
  877. __asm __saveds long cxenable_rxfunc (register __a1 ULONG *arg) {
  878.    return(BrokerCommand((char *) arg[0], CXCMD_ENABLE ) ? RETURN_ERROR : RETURN_OK);
  879. }
  880. static const struct Hook cxenable_rxhook = {
  881.    {NULL, NULL},
  882.    (void *)cxenable_rxfunc,
  883.    NULL,NULL
  884. };
  885.  
  886. __asm __saveds long cxdisable_rxfunc (register __a1 ULONG *arg) {
  887.    return(BrokerCommand((char *) arg[0], CXCMD_DISABLE ) ? RETURN_ERROR : RETURN_OK);
  888. }
  889. static const struct Hook cxdisable_rxhook = {
  890.    {NULL, NULL},
  891.    (void *)cxdisable_rxfunc,
  892.    NULL,NULL
  893. };
  894.  
  895. __asm __saveds long cxkill_rxfunc (register __a1 ULONG *arg) {
  896.    return(BrokerCommand((char *) arg[0], CXCMD_KILL ) ? RETURN_ERROR : RETURN_OK);
  897. }
  898. static const struct Hook cxkill_rxhook = {
  899.    {NULL, NULL},
  900.    (void *)cxkill_rxfunc,
  901.    NULL,NULL
  902. };
  903.  
  904. __asm __saveds long cxlistchg_rxfunc (register __a1 ULONG *arg) {
  905.    return(BrokerCommand((char *) arg[0], CXCMD_LIST_CHG ) ? RETURN_ERROR : RETURN_OK);
  906. }
  907. static const struct Hook cxlistchg_rxhook = {
  908.    {NULL, NULL},
  909.    (void *)cxlistchg_rxfunc,
  910.    NULL,NULL
  911. };
  912.  
  913. __asm __saveds long cxunique_rxfunc (register __a1 ULONG *arg) {
  914.    return(BrokerCommand((char *) arg[0], CXCMD_UNIQUE ) ? RETURN_ERROR : RETURN_OK);
  915. }
  916. static const struct Hook cxunique_rxhook = {
  917.    {NULL, NULL},
  918.    (void *)cxunique_rxfunc,
  919.    NULL,NULL
  920. };
  921.  
  922. __asm __saveds long removecx_rxfunc (register __a1 ULONG *arg) {
  923.    struct   Node  *node;
  924.  
  925.    if (node = MyFindName ("COMMODITIES", (char *) arg[0])) {
  926.       RemoveCxObj((CxObj *)node);
  927.       return (RETURN_OK);
  928.    }
  929.    return (RETURN_ERROR);
  930. }
  931. static const struct Hook removecx_rxhook = {
  932.    {NULL, NULL},
  933.    (void *)removecx_rxfunc,
  934.    NULL,NULL
  935. };
  936.  
  937. __asm __saveds long setcxpri_rxfunc (register __a1 ULONG *arg) {
  938.    struct   Node  *node;
  939.    long     pri;
  940.  
  941.    if ((node = MyFindName ("COMMODITIES", (char *) arg[0])) && (IsDec ((char *) arg[1], &pri))) {
  942.       if((pri>=-128) && (pri<=127)) {
  943.         struct List *list = MyGetList("COMMODITIES");
  944.         Forbid();
  945.         Remove(node);
  946.         node->ln_Pri = pri;
  947.         Enqueue(list,node);
  948.         Permit();
  949.         return (RETURN_OK);
  950.       }
  951.    }
  952.    return (RETURN_ERROR);
  953. }
  954. static const struct Hook setcxpri_rxhook = {
  955.    {NULL, NULL},
  956.    (void *)setcxpri_rxfunc,
  957.    NULL,NULL
  958. };
  959.  
  960.  
  961. struct MUI_Command arexx_list[] = {
  962.    {"PrintList"         , "LIST/A,FILENAME/A,APPEND/S", 3, &printlist_rxhook },
  963.    {"FindTask"          , "NAME=ADDRESS/A"           , 1, &findtask_rxhook },
  964.    {"FreezeTask"        , "NAME=ADDRESS/A"           , 1, &freezetask_rxhook },
  965.    {"ActivateTask"      , "NAME=ADDRESS/A"           , 1, &activatetask_rxhook },
  966.    {"RemoveTask"        , "NAME=ADDRESS/A,WITHPORTS/S", 2, &removetask_rxhook },
  967.    {"BreakTask"         , "NAME=ADDRESS/A"           , 1, &breaktask_rxhook },
  968.    {"SignalTask"        , "NAME=ADDRESS/A,HEXSIGNAL/A", 2, &signaltask_rxhook },
  969.    {"SetTaskPri"        , "NAME=ADDRESS/A,PRIORITY/A", 2, &settaskpri_rxhook },
  970.    {"RemovePort"        , "NAME=ADDRESS/A"           , 1, &removeport_rxhook },
  971.    {"GetLockNumber"     , "LOCKPATTERN/F"            , 1, &getlocknumber_rxhook },
  972.    {"RemoveLocks"       , "LOCKPATTERN/F"            , 1, &removelocks_rxhook },
  973.    {"RemoveLock"        , "ADDRESS/A"                , 1, &removelock_rxhook },
  974.    {"GetPriority"       , "ADDRESS/A"                , 1, &getpriority_rxhook },
  975.    {"SetPriority"       , "TYPE/A,NAME=ADDRESS/A,PRIORITY/N", 3, &setpriority_rxhook },
  976.    {"FindNode"          , "TYPE/A,NAME=ADDRESS/A"    , 2, &findnode_rxhook },
  977.    {"CloseLibrary"      , "NAME=ADDRESS/A"           , 1, &closelib_rxhook },
  978.    {"RemoveLibrary"     , "NAME=ADDRESS/A"           , 1, &removelib_rxhook },
  979.    {"RemoveDevice"      , "NAME=ADDRESS/A"           , 1, &removedev_rxhook },
  980.    {"RemoveResource"    , "NAME=ADDRESS/A"           , 1, &removeres_rxhook },
  981.    {"ObtainSemaphore"   , "NAME=ADDRESS/A"           , 1, &obtainsem_rxhook },
  982.    {"ReleaseSemaphore"  , "NAME=ADDRESS/A"           , 1, &releasesem_rxhook },
  983.    {"RemoveSemaphore"   , "NAME=ADDRESS/A"           , 1, &removesem_rxhook },
  984.    {"RemoveInputhandler", "NAME=ADDRESS/A"           , 1, &removeinput_rxhook },
  985.    {"RemoveLowMemory"   , "NAME=ADDRESS/A"           , 1, &removelowmemory_rxhook },
  986.    {"FindResident"      , "NAME=ADDRESS/A"           , 1, &findresident_rxhook },
  987.    {"FindInterrupt"     , "NAME/A"                   , 1, &findinterrupt_rxhook },
  988.    {"RemoveInterrupt"   , "NAME/A"                   , 1, &removeinterrupt_rxhook },
  989.    {"FlushDevs"         , NULL                       , 0, &flushdevs_rxhook },
  990.    {"FlushFonts"        , NULL                       , 0, &flushfonts_rxhook },
  991.    {"FlushLibs"         , NULL                       , 0, &flushlibs_rxhook },
  992.    {"FlushAll"          , NULL                       , 0, &flushall_rxhook },
  993.    {"ClearResetVectors" , NULL                       , 0, &clearreset_rxhook },
  994.    {"PopToFront"        , "TITLE=ADDRESS/A"          , 1, &poptofront_rxhook },
  995.    {"CloseWindow"       , "TITLE=ADDRESS/A"          , 1, &closewindow_rxhook },
  996.    {"CloseScreen"       , "TITLE=ADDRESS/A"          , 1, &closescreen_rxhook },
  997.    {"CloseFont"         , "ADDRESS/A"                , 1, &closefont_rxhook },
  998.    {"RemoveFont"        , "ADDRESS/A"                , 1, &removefont_rxhook },
  999.    {"RemoveCommand"     , "ADDRESS/A"                , 1, &removecommand_rxhook },
  1000.    {"RemoveAssign"      , "NAME/A"                   , 1, &removeassign_rxhook },
  1001.    {"RemoveAssignList"  , "NAME/A,ADDRESS/A"         , 2, &removeassignlist_rxhook },
  1002.    {"OpenWindow"        , "WINDOWID/F"               , 1, &openwindow_rxhook },
  1003.    {"CxAppear"          , "NAME/A"                   , 1, &cxappear_rxhook },
  1004.    {"CxDisappear"       , "NAME/A"                   , 1, &cxdisappear_rxhook },
  1005.    {"CxEnable"          , "NAME/A"                   , 1, &cxenable_rxhook },
  1006.    {"CxDisable"         , "NAME/A"                   , 1, &cxdisable_rxhook },
  1007.    {"CxKill"            , "NAME/A"                   , 1, &cxkill_rxhook },
  1008.    {"CxListChg"         , "NAME/A"                   , 1, &cxlistchg_rxhook },
  1009.    {"CxUnique"          , "NAME/A"                   , 1, &cxunique_rxhook },
  1010.    {"RemoveCx"          , "NAME=ADDRESS/A"           , 1, &removecx_rxhook },
  1011.    {"SetCxPri"          , "NAME=ADDRESS/A,PRIORITY/A", 2, &setcxpri_rxhook },
  1012. //*   {"CauseLowMemory"    , "NAME=ADDRESS/A"           , 1, &causelowmem_rxhook },
  1013.    {"RemoveClass"       , "NAME/A"                   , 1, &removeclass_rxhook },
  1014.    { NULL, NULL, 0, NULL }
  1015. };
  1016.  
  1017. char *FindMyARexxPort (char *name)
  1018. {
  1019.    char *result = NULL;
  1020.    struct   MsgPort  *port;
  1021.    struct   Task     *task;
  1022.    int      i;
  1023.  
  1024.    task = FindTask (NULL);
  1025.    for (i = 0; i < 10; i++) {
  1026.       _sprintf (tmpstr, "%s.%ld", name, i);
  1027.  
  1028.       Forbid();
  1029.       port = FindPort (tmpstr);
  1030.       Permit();
  1031.  
  1032.       if (port != NULL && port->mp_SigTask == task) {
  1033.          result = port->mp_Node.ln_Name;
  1034.          break;
  1035.       }
  1036.    }
  1037.    return result;
  1038. }
  1039.  
  1040. ULONG SafePutToPort(struct Message *message, STRPTR portname) {
  1041.    struct MsgPort *port;
  1042.  
  1043.    Forbid();
  1044.    if (port = FindPort(portname))
  1045.       PutMsg (port,message);
  1046.    Permit();
  1047.    return ((ULONG) port); /* If zero, the port has gone away */
  1048. }
  1049.  
  1050. short SendStartupMsg (char *PortName,char *RString,BOOL IsFileName) {
  1051.    register struct   RexxMsg  *rmsg;
  1052.    register short    flag = FALSE;
  1053.  
  1054.    char     *buffer = NULL;
  1055.    ULONG    buflen;
  1056.  
  1057.    if ((RString) && (rmsg = CreateRexxMsg(ScoutPort,NULL,PortName))) {
  1058.  
  1059.       rmsg->rm_Action = (RXCOMM|RXFF_STRING);
  1060.  
  1061.       if (IsFileName) {
  1062.          buflen = strlen (RString) + 4;
  1063.  
  1064.          if (buffer = AllocVec(buflen, MEMF_ANY)) {
  1065.             /*
  1066.              * Fill in the hostname and the command
  1067.              */
  1068.             _sprintf (buffer, "'%s'", RString);
  1069.  
  1070.             rmsg->rm_Args[0] = CreateArgstring (buffer, buflen);
  1071.          }
  1072.       } else {          
  1073.          rmsg->rm_Args[0] = CreateArgstring (RString,(LONG) strlen (RString));
  1074.       }
  1075.  
  1076.       if (rmsg->rm_Args[0]) {
  1077.          if (SafePutToPort ((struct Message *) rmsg, RXSDIR)) {
  1078.             flag=TRUE;
  1079.          } else {
  1080.             DeleteArgstring (rmsg->rm_Args[0]);
  1081.             DeleteRexxMsg (rmsg);
  1082.          }
  1083.       } else {
  1084.             DeleteRexxMsg (rmsg);
  1085.       }
  1086.  
  1087.       if (buffer) FreeVec(buffer);
  1088.    }
  1089.    return (flag);
  1090. }
  1091.  
  1092.  
  1093. /********************************************************************/
  1094. /*         Neue Hilfsroutinen für die ARexx-Funktionen              */
  1095. /********************************************************************/
  1096.  
  1097. struct Task *MyFindTask (char *stask) {
  1098.    struct   Task  *lauf, *task, *result = NULL;
  1099.  
  1100.    if (IsHex (stask, (long *) &task)) {
  1101.       Forbid();
  1102.  
  1103.       lauf = FIRSTTASKREADY;
  1104.       while ((! result) && (lauf->tc_Node.ln_Succ != 0)) {
  1105.          if (task == lauf)
  1106.             result = lauf;
  1107.          lauf = (struct Task *) lauf->tc_Node.ln_Succ;
  1108.       }
  1109.  
  1110.       lauf = FIRSTTASKWAIT;
  1111.       while ((! result) && (lauf->tc_Node.ln_Succ != 0)) {
  1112.          if (task == lauf)
  1113.             result = lauf;
  1114.          lauf = (struct Task *) lauf->tc_Node.ln_Succ;
  1115.       }
  1116.       Permit();
  1117.  
  1118.       if ((! result) && (task == FindTask (NULL)))
  1119.          result = task;
  1120.  
  1121.    } else {
  1122.       Forbid();
  1123.  
  1124.       lauf = FIRSTTASKREADY;
  1125.       while ((! result) && (lauf->tc_Node.ln_Succ != 0)) {
  1126.          if (stricmp (stask, GetTaskName (lauf)) == 0) 
  1127.             result = lauf;
  1128.    
  1129.          lauf = (struct Task *) lauf->tc_Node.ln_Succ;
  1130.       }
  1131.  
  1132.       lauf = FIRSTTASKWAIT;
  1133.       while ((! result) && (lauf->tc_Node.ln_Succ != 0)) {
  1134.          if (stricmp (stask, GetTaskName (lauf)) == 0) 
  1135.             result = lauf;
  1136.    
  1137.          lauf = (struct Task *) lauf->tc_Node.ln_Succ;
  1138.       }
  1139.       Permit();
  1140.  
  1141.       if ((! result) && (stricmp (stask, GetTaskName (lauf = FindTask (NULL))) == 0)) 
  1142.          result = lauf;
  1143.    }
  1144.    return (result);
  1145. }
  1146.  
  1147. BOOL MyRemoveTask (char *stask, BOOL withports) {
  1148.    struct   Task     *task;
  1149.    struct   MsgPort  *port, *nextport;
  1150.    struct   Window   *window, *nextwindow;
  1151.    struct   Screen   *screen, *nextscreen;
  1152.    struct   SignalSemaphore   *sem, *nextsem;
  1153.    BOOL     allwins = FALSE;
  1154.  
  1155.    Forbid();
  1156.    if (task = MyFindTask (stask)) {
  1157.  
  1158.    // Wegen groben Unfugs gestrichen!
  1159.  
  1160.       if (MyFreezeTask (stask) && withports) {
  1161.          port = FIRSTPORT;
  1162.          while (port) {
  1163.             nextport = (struct MsgPort *) port->mp_Node.ln_Succ;
  1164.             if (port->mp_SigTask == task) {
  1165.                RemPort (port);
  1166.             }
  1167.             port = nextport;
  1168.          }
  1169.  
  1170.  
  1171.          sem = FIRSTSEMAPHORE;
  1172.          while (nextsem = (struct SignalSemaphore *) sem->ss_Link.ln_Succ) {
  1173.  
  1174.             if (sem->ss_Owner == task) {
  1175.                int tmpint = sem->ss_NestCount;
  1176.                while (tmpint-- > 0) {
  1177.                   ReleaseSemaphore (sem);
  1178.                }
  1179.             }
  1180.             sem = nextsem;
  1181.          }
  1182.  
  1183.          screen = FIRSTSCREEN;
  1184.          while (screen) {
  1185.             nextscreen = screen->NextScreen;
  1186.  
  1187.             if (window = screen->FirstWindow) {
  1188.                allwins = TRUE;
  1189.  
  1190.                while (window) {
  1191.                   nextwindow = window->NextWindow;
  1192.  
  1193.                   if (window->UserPort->mp_SigTask == task) {
  1194.                      CloseWindow (window);
  1195.                   } else {
  1196.                      allwins = FALSE;
  1197.                   }
  1198.                   window = nextwindow;
  1199.                }
  1200.             }
  1201.  
  1202.             if (allwins && !screen->FirstWindow)
  1203.                CloseScreen (screen);
  1204.  
  1205.             screen = nextscreen;
  1206.          }
  1207.       }
  1208.  
  1209.       RemTask (task);
  1210.       Permit();
  1211.       return (TRUE);
  1212.    }
  1213.    Permit();
  1214.    return (FALSE);
  1215. }
  1216.  
  1217. BOOL MyFreezeTask (char *stask)
  1218. {
  1219.    BOOL result = FALSE;
  1220.    struct   Task     *task;
  1221.  
  1222.    Forbid();
  1223.    if (task = MyFindTask (stask)) {
  1224.       Remove ((struct Node *) task);
  1225.       task->tc_State = (BYTE) TS_FROZEN;
  1226.       Enqueue ((struct List *) &SysBase->TaskWait, (struct Node *) task);
  1227.       result = TRUE;
  1228.    }
  1229.    Permit();
  1230.  
  1231.    return result;
  1232. }
  1233.  
  1234. BOOL MyActivateTask (char *stask)
  1235. {
  1236.    BOOL result = FALSE;
  1237.    struct   Task     *task;
  1238.  
  1239.    Forbid();
  1240.    if (task = MyFindTask (stask)) {
  1241.       Remove ((struct Node *) task);
  1242.       task->tc_State = (BYTE) TS_READY;
  1243.       Enqueue ((struct List *) &SysBase->TaskReady, (struct Node *) task);
  1244.       result = TRUE;
  1245.    }
  1246.    Permit();
  1247.  
  1248.    return result;
  1249. }
  1250.  
  1251. BOOL MySignalTask (char *stask, char *ssignal)
  1252. {
  1253.    BOOL result = FALSE;
  1254.    struct   Task     *task;
  1255.    long     signal;
  1256.  
  1257.    Forbid();
  1258.    if ((task = MyFindTask (stask)) && (IsHex (ssignal, &signal))) {
  1259.       Signal (task, signal);
  1260.       result = TRUE;
  1261.    }
  1262.    Permit();
  1263.  
  1264.    return result;
  1265. }
  1266.  
  1267. static char *nodetype[] = {
  1268.    "LIBRARY", "DEVICE", "RESOURCE", "MEMORY", "SEMAPHORE", 
  1269.    "PORT", "INPUTHANDLER", "LOWMEMORY", "COMMODITIES", "CLASSES", NULL
  1270. };
  1271.  
  1272. struct List *MyGetList (char *type) {
  1273.    int      i = 0;
  1274.    char     *tmp;
  1275.    struct   List  *list = NULL;
  1276.  
  1277.    while (nodetype[i]) {
  1278.       if (! stricmp (nodetype[i], type)) {
  1279.          switch (i) {
  1280.             case 0:
  1281.                list = &SysBase->LibList;
  1282.                break;
  1283.             case 1:
  1284.                list = &SysBase->DeviceList;
  1285.                break;
  1286.             case 2:
  1287.                list = &SysBase->ResourceList;
  1288.                break;
  1289.             case 3:
  1290.                list = &SysBase->MemList;
  1291.                break;
  1292.             case 4:
  1293.                list = &SysBase->SemaphoreList;
  1294.                break;
  1295.             case 5:
  1296.                list = &SysBase->PortList;
  1297.                break;
  1298.             case 6:
  1299.                if (list = (struct List *) FindName (&SysBase->DeviceList, "input.device")) {
  1300.                   tmp = (char *) list;
  1301.                   tmp += 148;    /* Mir unbekannter Offsetname! */
  1302.                   list = (struct List *) ((struct Node *) tmp)->ln_Succ;
  1303.                }
  1304.                break;
  1305.             case 7:
  1306.                if (SysBase->LibNode.lib_Version >= 39)
  1307.                  list = (struct List *)&SysBase->ex_MemHandlers;
  1308.                else
  1309.                  list = NULL;
  1310.                break;
  1311.             case 8:
  1312.                {
  1313.                   struct MsgPort *cxport;
  1314.                   struct NewBroker cxnewbroker =
  1315.                   {
  1316.                     NB_VERSION,
  1317.                     "« Scout Dummy »",
  1318.                     "« Scout Dummy »",
  1319.                     "Dummy Broker",
  1320.                     0,
  1321.                     0,
  1322.                     0,
  1323.                     NULL,
  1324.                     0
  1325.                   };
  1326.                   struct Node *cxbroker;
  1327.                   struct Node *broker;
  1328.  
  1329.                   if(cxport = CreateMsgPort()) {
  1330.                      cxnewbroker.nb_Port = cxport;
  1331.                      if(cxbroker = (struct Node *)CxBroker(&cxnewbroker,NULL)) {
  1332.                           Forbid();
  1333.                           for(broker=cxbroker; broker->ln_Pred; broker=broker->ln_Pred);   /* Search the list head */
  1334.                           list = (struct List *)broker;
  1335.                           Permit();
  1336.                         DeleteCxObjAll((CxObj *)cxbroker);
  1337.                      }
  1338.                      DeleteMsgPort(cxport);
  1339.                   }
  1340.                }
  1341.                break;
  1342.             case 9:
  1343.                {
  1344.                   struct IClass *myclass = MakeClass("« Scout Dummy Class »","rootclass",NULL,0,0);
  1345.                   struct Node *clist;
  1346.                   if(myclass) {
  1347.                      AddClass(myclass);
  1348.                      Forbid();
  1349.                         for(clist=(struct Node *)&myclass->cl_Dispatcher.h_MinNode; clist->ln_Pred; clist=clist->ln_Pred);   /* Search the list head */
  1350.                         list = (struct List *)clist;
  1351.                      Permit();
  1352.                      FreeClass(myclass);
  1353.                   }
  1354.                }
  1355.                break;
  1356.           }
  1357.       }
  1358.       i++;
  1359.    }
  1360.    return (list);
  1361. }
  1362.  
  1363. struct Node *MyFindName (char *type, char *sname) {
  1364.    struct   List  *list;
  1365.    struct   Node  *lauf, *node = NULL, *result = NULL;
  1366.  
  1367.    if (list = MyGetList (type)) {
  1368.       if (IsHex (sname, (long *) &node)) {
  1369.          Forbid();
  1370.  
  1371.          lauf = list->lh_Head;
  1372.          while (lauf->ln_Succ != 0) {
  1373.             if (node == lauf) {
  1374.                result = lauf;
  1375.                break;
  1376.             }
  1377.             lauf = lauf->ln_Succ;
  1378.          }
  1379.  
  1380.          Permit();
  1381.       } else {
  1382.          result = FindName (list, sname);
  1383.       }
  1384.    }
  1385.    return (result);
  1386. }
  1387.  
  1388. struct Screen *MyFindScreen (char *sname) {
  1389.    struct   Screen   *screen = NULL, *lauf;
  1390.  
  1391.    lauf = FIRSTSCREEN;
  1392.    IsHex (sname, (long *) &screen);
  1393.    
  1394.    while (lauf) {
  1395.       if (screen) {
  1396.          if (lauf == screen)
  1397.             return (lauf);
  1398.       } else {
  1399.          if (stricmp (sname, nonetest (lauf->Title)) == 0)
  1400.             return (lauf);
  1401.       }
  1402.       lauf = lauf->NextScreen;
  1403.    }
  1404.    return (NULL);
  1405. }
  1406.  
  1407. struct Window *MyFindWindow (char *sname) {
  1408.    struct   Window   *window, *lauf;
  1409.    struct   Screen   *screen;
  1410.  
  1411.    screen = FIRSTSCREEN;
  1412.    IsHex (sname, (long *) &window);
  1413.    
  1414.    while (screen) {
  1415.       lauf = screen->FirstWindow;
  1416.  
  1417.       while (lauf) {
  1418.          if (window) {
  1419.             if (lauf == window)
  1420.                return (lauf);
  1421.          } else {
  1422.             if (stricmp (sname, nonetest (lauf->Title)) == 0)
  1423.                return (lauf);
  1424.          }
  1425.          lauf = lauf->NextWindow;
  1426.       }
  1427.       screen = screen->NextScreen;
  1428.    }
  1429.    return (NULL);
  1430. }
  1431.